home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / circuits / spice2g6.z / spice2g6 / spice / Fortran / load.f < prev    next >
Encoding:
Text File  |  1989-02-03  |  11.0 KB  |  370 lines
  1.       subroutine load
  2.       implicit double precision (a-h,o-z)
  3. c
  4. c     this routine zeroes-out and then loads the coefficient matrix.
  5. c the active devices and the controlled sources are loaded by separate
  6. c subroutines.
  7. c
  8. c spice version 2g.6  sccsid=tabinf 3/15/83
  9.       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem,
  10.      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize,
  11.      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr,
  12.      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1,
  13.      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd,
  14.      5   imynl,imvn,lcvn,nsnod,nsmat,nsval,icnod,icmat,icval,
  15.      6   loutpt,lpol,lzer,irswpf,irswpr,icswpf,icswpr,irpt,jcpt,
  16.      7   irowno,jcolno,nttbr,nttar,lvntmp
  17. c spice version 2g.6  sccsid=cirdat 3/15/83
  18.       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop,
  19.      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs,numalt,numcyc
  20. c spice version 2g.6  sccsid=status 3/15/83
  21.       common /status/ omega,time,delta,delold(7),ag(7),vt,xni,egfet,
  22.      1   xmu,sfactr,mode,modedc,icalc,initf,method,iord,maxord,noncon,
  23.      2   iterno,itemno,nosolv,modac,ipiv,ivmflg,ipostp,iscrch,iofile
  24. c spice version 2g.6  sccsid=miscel 3/15/83
  25.       common /miscel/ atime,aprog(3),adate,atitle(10),defl,defw,defad,
  26.      1  defas,rstats(50),iwidth,lwidth,nopage
  27. c spice version 2g.6  sccsid=flags 3/15/83
  28.       common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts,
  29.      1   lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,itl6,igoof,nogo,keof
  30. c spice version 2g.6  sccsid=knstnt 3/15/83
  31.       common /knstnt/ twopi,xlog2,xlog10,root2,rad,boltz,charge,ctok,
  32.      1   gmin,reltol,abstol,vntol,trtol,chgtol,eps0,epssil,epsox,
  33.      2   pivtol,pivrel
  34. c spice version 2g.6  sccsid=blank 3/15/83
  35.       common /blank/ value(200000)
  36.       integer nodplc(64)
  37.       complex cvalue(32)
  38.       equivalence (value(1),nodplc(1),cvalue(1))
  39. c
  40. c
  41.       dimension qcap(1),ccap(1)
  42.       equivalence (qcap(1),value(1)),(ccap(1),value(2))
  43.       dimension find(1),vind(1)
  44.       equivalence (find(1),value(1)),(vind(1),value(2))
  45. c
  46.       call second(t1)
  47. c
  48. c  zero y matrix and current vector
  49. c
  50.       call zero8(value(lvn+1),nstop+nttbr)
  51. c
  52. c  resistors
  53. c
  54.       loc=locate(1)
  55.    20 if ((loc.eq.0).or.(nodplc(loc+8).ne.0)) go to 30
  56.       locv=nodplc(loc+1)
  57.       val=value(locv+1)
  58.       locy=lvn+nodplc(loc+6)
  59.       value(locy)=value(locy)+val
  60.       locy=lvn+nodplc(loc+7)
  61.       value(locy)=value(locy)+val
  62.       locy=lvn+nodplc(loc+4)
  63.       value(locy)=value(locy)-val
  64.       locy=lvn+nodplc(loc+5)
  65.       value(locy)=value(locy)-val
  66.       loc=nodplc(loc)
  67.       go to 20
  68. c
  69. c  capacitors
  70. c
  71.    30 loc=locate(2)
  72.       if ((mode.eq.1).and.(modedc.ne.2)) go to 100
  73.    40 if ((loc.eq.0).or.(nodplc(loc+12).ne.0)) go to 100
  74.       locv=nodplc(loc+1)
  75.       node1=nodplc(loc+2)
  76.       node2=nodplc(loc+3)
  77.       loct=nodplc(loc+8)
  78.       ipoly=nodplc(loc+4)
  79.       if (ipoly.eq.1) go to 43
  80.       lcoef=nodplc(loc+7)
  81.       call sizmem(nodplc(loc+7),ncoef)
  82.    43 vcap=value(locv+2)
  83.       if ((mode.eq.1).and.(initf.eq.2)) go to 45
  84.       if ((nosolv.ne.0).and.(initf.eq.5)) go to 45
  85.       vcap=value(lvnim1+node1)-value(lvnim1+node2)
  86.    45 value(locv+3)=vcap
  87.       if (mode.eq.1) go to 60
  88.    47 if (initf.ne.6) go to 50
  89.       qcap(lx0+loct)=qcap(lx1+loct)
  90.       go to 60
  91.    50 if (ipoly.eq.0) go to 53
  92.       qcap(lx0+loct)=value(locv+1)*vcap
  93.       if (initf.ne.5) go to 60
  94.       if (nosolv.ne.0) qcap(lx0+loct)=value(locv+1)*value(locv+2)
  95.       qcap(lx1+loct)=qcap(lx0+loct)
  96.       go to 60
  97.    53 call evpoly(qcap(lx0+loct),-1,lcoef,ncoef,locv+2,1,loc+8)
  98.       if (initf.ne.5) go to 60
  99.       if (nosolv.eq.0) go to 55
  100.       vcap=value(locv+2)
  101.       value(locv+3)=vcap
  102.       call evpoly(qcap(lx0+loct),-1,lcoef,ncoef,locv+2,1,loc+8)
  103.    55 qcap(lx1+loct)=qcap(lx0+loct)
  104.    60 if (ipoly.eq.1) go to 62
  105.       call evpoly(value(locv+1),0,lcoef,ncoef,locv+2,1,loc+8)
  106.    62 if (mode.eq.1) go to 90
  107.       call intgr8(geq,ceq,value(locv+1),loct)
  108.       if (ipoly.eq.1) go to 65
  109.       ceq=ceq-geq*vcap+ag(1)*qcap(lx0+loct)
  110.    65 if(initf.ne.5) go to 70
  111.       ccap(lx1+loct)=ccap(lx0+loct)
  112.    70 locy=lvn+nodplc(loc+10)
  113.       value(locy)=value(locy)+geq
  114.       locy=lvn+nodplc(loc+11)
  115.       value(locy)=value(locy)+geq
  116.       locy=lvn+nodplc(loc+5)
  117.       value(locy)=value(locy)-geq
  118.       locy=lvn+nodplc(loc+6)
  119.       value(locy)=value(locy)-geq
  120.       value(lvn+node1)=value(lvn+node1)-ceq
  121.       value(lvn+node2)=value(lvn+node2)+ceq
  122.    90 loc=nodplc(loc)
  123.       go to 40
  124. c
  125. c  inductors
  126. c
  127.   100 if (jelcnt(3).eq.0) go to 400
  128.       if (mode.eq.1) go to 150
  129.       if (initf.eq.6) go to 150
  130.       loc=locate(3)
  131.   110 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 120
  132.       locv=nodplc(loc+1)
  133.       iptr=nodplc(loc+5)
  134.       loct=nodplc(loc+11)
  135.       ipoly=nodplc(loc+4)
  136.       if (ipoly.eq.0) go to 115
  137.       find(lx0+loct)=value(locv+1)*value(lvnim1+iptr)
  138.       if ((initf.eq.5).and.(nosolv.ne.0))
  139.      1   find(lx0+loct)=value(locv+1)*value(locv+2)
  140.       go to 118
  141.   115 lcoef=nodplc(loc+10)
  142.       call sizmem(nodplc(loc+10),ncoef)
  143.       cind=value(lvnim1+iptr)
  144.       if ((initf.eq.5).and.(nosolv.ne.0)) cind=value(locv+2)
  145.       value(locv+3)=cind
  146.       call evpoly(find(lx0+loct),-1,lcoef,ncoef,locv+2,1,loc+11)
  147.   118 loc=nodplc(loc)
  148.       go to 110
  149.   120 loc=locate(4)
  150.   130 if ((loc.eq.0).or.(nodplc(loc+6).ne.0)) go to 150
  151.       locv=nodplc(loc+1)
  152.       nl1=nodplc(loc+2)
  153.       nl2=nodplc(loc+3)
  154.       iptr1=nodplc(nl1+5)
  155.       iptr2=nodplc(nl2+5)
  156.       loct1=nodplc(nl1+11)
  157.       loct2=nodplc(nl2+11)
  158.       find(lx0+loct1)=find(lx0+loct1)+value(locv+1)*value(lvnim1+iptr2)
  159.       find(lx0+loct2)=find(lx0+loct2)+value(locv+1)*value(lvnim1+iptr1)
  160.       loc=nodplc(loc)
  161.       go to 130
  162.   150 loc=locate(3)
  163.   160 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 300
  164.       locv=nodplc(loc+1)
  165.       iptr=nodplc(loc+5)
  166.       loct=nodplc(loc+11)
  167.       ipoly=nodplc(loc+4)
  168.       if (ipoly.eq.1) go to 170
  169.       lcoef=nodplc(loc+10)
  170.       call sizmem(nodplc(loc+10),ncoef)
  171.   170 cind=value(lvnim1+iptr)
  172.       if ((nosolv.ne.0).and.(initf.eq.5)) cind=value(locv+2)
  173.       value(locv+3)=cind
  174.   180 if (mode.ne.1) go to 200
  175.       veq=0.0d0
  176.       req=0.0d0
  177.       go to 210
  178.   200 if (initf.ne.6) go to 205
  179.       find(lx0+loct)=find(lx1+loct)
  180.       go to 210
  181.   205 if (initf.ne.5) go to 210
  182.       find(lx1+loct)=find(lx0+loct)
  183.   210 if (ipoly.eq.1) go to 220
  184.       call evpoly(value(locv+1),0,lcoef,ncoef,locv+2,1,loc+11)
  185.   220 if (mode.eq.1) go to 250
  186.       call intgr8(req,veq,value(locv+1),loct)
  187.       if (ipoly.eq.1) go to 250
  188.       veq=veq-req*cind+ag(1)*find(lx0+loct)
  189.   250 value(lvn+iptr)=veq
  190.       if(initf.ne.5) go to 260
  191.       vind(lx1+loct)=vind(lx0+loct)
  192.   260 locy=lvn+nodplc(loc+13)
  193.       value(locy)=-req
  194.       locy=lvn+nodplc(loc+6)
  195.       value(locy)=1.0d0
  196.       locy=lvn+nodplc(loc+7)
  197.       value(locy)=-1.0d0
  198.       locy=lvn+nodplc(loc+8)
  199.       value(locy)=1.0d0
  200.       locy=lvn+nodplc(loc+9)
  201.       value(locy)=-1.0d0
  202.       loc=nodplc(loc)
  203.       go to 160
  204. c
  205. c  mutual inductances
  206. c
  207.   300 loc=locate(4)
  208.   310 if ((loc.eq.0).or.(nodplc(loc+6).ne.0)) go to 400
  209.       locv=nodplc(loc+1)
  210.       req=ag(1)*value(locv+1)
  211.       locy=lvn+nodplc(loc+4)
  212.       value(locy)=-req
  213.       locy=lvn+nodplc(loc+5)
  214.       value(locy)=-req
  215.       loc=nodplc(loc)
  216.       go to 310
  217. c
  218. c  nonlinear controlled sources
  219. c
  220.   400 call nlcsrc
  221. c
  222. c  voltage sources
  223. c
  224.       loc=locate(9)
  225.   610 if ((loc.eq.0).or.(nodplc(loc+11).ne.0)) go to 700
  226.       locv=nodplc(loc+1)
  227.       iptr=nodplc(loc+6)
  228.       value(lvn+iptr)=value(locv+1)*sfactr
  229.       locy=lvn+nodplc(loc+7)
  230.       value(locy)=value(locy)+1.0d0
  231.       locy=lvn+nodplc(loc+8)
  232.       value(locy)=value(locy)-1.0d0
  233.       locy=lvn+nodplc(loc+9)
  234.       value(locy)=value(locy)+1.0d0
  235.       locy=lvn+nodplc(loc+10)
  236.       value(locy)=value(locy)-1.0d0
  237.       loc=nodplc(loc)
  238.       go to 610
  239. c
  240. c  current sources
  241. c
  242.   700 loc=locate(10)
  243.   710 if ((loc.eq.0).or.(nodplc(loc+6).ne.0)) go to 800
  244.       locv=nodplc(loc+1)
  245.       node1=nodplc(loc+2)
  246.       node2=nodplc(loc+3)
  247.       val=value(locv+1)*sfactr
  248.       value(lvn+node1)=value(lvn+node1)-val
  249.       value(lvn+node2)=value(lvn+node2)+val
  250.       loc=nodplc(loc)
  251.       go to 710
  252. c
  253. c  call device model routines
  254. c
  255.   800 call diode
  256.       call bjt
  257.       call jfet
  258.       call mosfet
  259. c
  260. c  transmission lines
  261. c
  262.       loc=locate(17)
  263.   910 if ((loc.eq.0).or.(nodplc(loc+33).ne.0)) go to 980
  264.       locv=nodplc(loc+1)
  265.       z0=value(locv+1)
  266.       y0=1.0d0/z0
  267.       node1=nodplc(loc+2)
  268.       node2=nodplc(loc+3)
  269.       node3=nodplc(loc+4)
  270.       node4=nodplc(loc+5)
  271.       ibr1=nodplc(loc+8)
  272.       ibr2=nodplc(loc+9)
  273.       locy=lvn+nodplc(loc+10)
  274.       value(locy)=value(locy)+y0
  275.       locy=lvn+nodplc(loc+11)
  276.       value(locy)=-y0
  277.       locy=lvn+nodplc(loc+12)
  278.       value(locy)=-1.0d0
  279.       locy=lvn+nodplc(loc+13)
  280.       value(locy)=value(locy)+y0
  281.       locy=lvn+nodplc(loc+14)
  282.       value(locy)=-1.0d0
  283.       locy=lvn+nodplc(loc+15)
  284.       value(locy)=-y0
  285.       locy=lvn+nodplc(loc+16)
  286.       value(locy)=+y0
  287.       locy=lvn+nodplc(loc+17)
  288.       value(locy)=+1.0d0
  289.       locy=lvn+nodplc(loc+18)
  290.       value(locy)=+y0
  291.       locy=lvn+nodplc(loc+19)
  292.       value(locy)=+1.0d0
  293.       locy=lvn+nodplc(loc+20)
  294.       value(locy)=-1.0d0
  295.       locy=lvn+nodplc(loc+23)
  296.       value(locy)=+1.0d0
  297.       locy=lvn+nodplc(loc+27)
  298.       value(locy)=-1.0d0
  299.       locy=lvn+nodplc(loc+28)
  300.       value(locy)=+1.0d0
  301.       locy=lvn+nodplc(loc+31)
  302.       value(locy)=-y0
  303.       locy=lvn+nodplc(loc+32)
  304.       value(locy)=-y0
  305.       if (mode.ne.1) go to 920
  306.       locy=lvn+nodplc(loc+21)
  307.       value(locy)=-1.0d0
  308.       locy=lvn+nodplc(loc+22)
  309.       value(locy)=+1.0d0
  310.       locy=lvn+nodplc(loc+24)
  311.       value(locy)=-(1.0d0-gmin)*z0
  312.       locy=lvn+nodplc(loc+25)
  313.       value(locy)=-1.0d0
  314.       locy=lvn+nodplc(loc+26)
  315.       value(locy)=+1.0d0
  316.       locy=lvn+nodplc(loc+29)
  317.       value(locy)=-(1.0d0-gmin)*z0
  318.       go to 950
  319.   920 if (initf.ne.5) go to 930
  320.       if (nosolv.ne.0) go to 925
  321.       value(locv+3)=value(lvnim1+node3)-value(lvnim1+node4)
  322.      1   +value(lvnim1+ibr2)*z0
  323.       value(locv+4)=value(lvnim1+node1)-value(lvnim1+node2)
  324.      1   +value(lvnim1+ibr1)*z0
  325.       go to 930
  326.   925 value(locv+3)=value(locv+7)+value(locv+8)*z0
  327.       value(locv+4)=value(locv+5)+value(locv+6)*z0
  328.   930 value(lvn+ibr1)=value(locv+3)
  329.       value(lvn+ibr2)=value(locv+4)
  330.   950 loc=nodplc(loc)
  331.       go to 910
  332. c
  333. c  initialize nodes
  334. c
  335.   980 if(mode.ne.1) go to 995
  336.       if(initf.ne.3.and.initf.ne.2) go to 995
  337.       call sizmem(nsnod,nic)
  338.       if(nic.eq.0) go to 995
  339.       call sizmem(icnod,ntest)
  340.       if(modedc.eq.2.and.ntest.ne.0) go to 995
  341.       g=1.0d0
  342.       do 990 i=1,nic
  343.       locy=lvn+nodplc(nsmat+i)
  344.       value(locy)=value(locy)+g
  345.       node=nodplc(nsnod+i)
  346.       value(lvn+node)=value(lvn+node)+value(nsval+i)*g
  347.   990 continue
  348. c
  349. c  transient initial conditions (uic not specified)
  350. c
  351.   995 if(mode.ne.1) go to 1000
  352.       if(modedc.ne.2) go to 1000
  353.       if(nosolv.ne.0) go to 1000
  354.       call sizmem(icnod,nic)
  355.       if(nic.eq.0) go to 1000
  356.       g=1.0d0
  357.       do 996 i=1,nic
  358.       locy=lvn+nodplc(icmat+i)
  359.       value(locy)=value(locy)+g
  360.       node=nodplc(icnod+i)
  361.       value(lvn+node)=value(lvn+node)+value(icval+i)*g
  362.   996 continue
  363. c
  364. c  finished
  365. c
  366.  1000 call second(t2)
  367.       rstats(45)=rstats(45)+t2-t1
  368.       return
  369.       end
  370.